Comment annuler 'git add' avant de commettre?

1
2
Prochain
Vous pouvez annuler git add avant de commettre avec
git reset 
ce qui le supprimera de l'index courant (la liste "sur le point d'être validée") sans rien changer d'autre.
Vous pouvez utiliser
git reset
sans aucun nom de fichier pour annuler toutes les modifications dues. Cela peut être utile lorsqu'il y a trop de fichiers pour être répertoriés un par un dans un laps de temps raisonnable.
Dans les anciennes versions de Git, les commandes ci-dessus sont respectivement équivalentes à git reset HEAD  et git reset HEAD, et échoueront si HEAD n'est pas défini (car vous n'avez pas encore effectué de validation dans votre référentiel) ou ambiguë (car vous créé une branche appelée HEAD, ce qui est une chose stupide que vous ne devriez pas faire). Cela a cependant été changé dans Git 1.8.2, donc dans les versions modernes de Git, vous pouvez utiliser les commandes ci-dessus avant même de faire votre premier commit:
"git reset" (sans options ni paramètres) utilisé pour l'erreur lorsque
vous n'avez aucun commit dans votre historique, mais cela vous donne maintenant
un index vide (pour correspondre à un commit inexistant, vous n'êtes même pas sur).
Documentation: git reset
|
Tu veux:
git rm --cached 
Raisonnement:
Quand j'étais nouveau dans ce domaine, j'ai d'abord essayé
git reset.
(pour annuler tout mon ajout initial), uniquement pour obtenir ce message (pas si) utile:
fatal: échec de la résolution de «HEAD» en tant que référence valide.
Il s'avère que c'est parce que la référence HEAD (branche?) N'existe qu'après le premier commit. Autrement dit, vous rencontrerez le même problème de débutant que moi si votre flux de travail, comme le mien, était quelque chose comme:
cd dans mon nouveau répertoire de projet pour essayer Git, le nouveau hotness
git init
git add.
état de git
... beaucoup de merde défile par ...
=> Merde, je ne voulais pas ajouter tout ça.
google "annuler git add"
=> trouver Stack Overflow - yay
git reset.
=> fatal: échec de la résolution de 'HEAD' en tant que référence valide.
Il s'avère en outre qu'il y a un bug enregistré contre l'inutilité de cela dans la liste de diffusion.
Et que la solution correcte était là dans la sortie d'état de Git (ce que, oui, j'ai passé sous silence comme de la merde)
...
# Modifications à valider:
# (utilisez "git rm --cached  ..." pour désinstaller)
...
Et la solution est en effet d'utiliser git rm --cached FILE.
Notez les avertissements ailleurs ici - git rm supprime votre copie de travail locale du fichier, mais pas si vous utilisez --cached. Voici le résultat de git help rm:
--caché
Utilisez cette option pour désinstaller et supprimer des chemins uniquement de l'index.
Les fichiers d'arborescence de travail, modifiés ou non, seront laissés.
Je procède à l'utilisation
git rm - en cache.
pour tout supprimer et recommencer. Cela n'a pas fonctionné cependant, car tout ajouter. est récursif, il s'avère que rm a besoin de -r pour récurer. Soupir.
git rm -r --cached.
Ok, maintenant je suis de retour là où j'ai commencé. La prochaine fois, je vais utiliser -n pour faire un essai et voir ce qui sera ajouté:
git ajouter -n.
J'ai tout zippé dans un endroit sûr avant de faire confiance à git help rm à propos du --cached ne détruisant rien (et si je l'ai mal orthographié).
|
Si vous tapez:
état git
Git vous dira ce qui est mis en scène, etc., y compris des instructions sur la façon de désinstaller:
utilisez "git reset HEAD  ..." pour désinstaller
Je trouve que Git fait un très bon travail en me poussant à faire ce qu'il faut dans des situations comme celle-ci.
Remarque: les versions récentes de Git (1.8.4.x) ont modifié ce message:
(utilisez "git rm --cached  ..." pour désinstaller)
|
Pour clarifier: git add déplace les modifications du répertoire de travail actuel vers la zone de préparation (index).
Ce processus s'appelle la mise en scène. La commande la plus naturelle pour organiser les changements (fichiers modifiés) est donc la plus évidente:
étape git
git add est juste un alias plus facile à taper pour git stage
Dommage qu'il n'y ait pas de commandes git unstage ni git unadd. Le plus pertinent est plus difficile à deviner ou à retenir, mais il est assez évident:
git reset HEAD -
Nous pouvons facilement créer un alias pour cela:
git config --global alias.unadd 'reset HEAD -'
git config --global alias.unstage 'reset HEAD -'
Et enfin, nous avons de nouvelles commandes:
git add file1
git stage fichier2
git unadd fichier2
git unstage file1
Personnellement, j'utilise des alias encore plus courts:
git a # Pour la mise en scène
git u # Pour désinstaller
|
Un ajout à la réponse acceptée, si votre fichier ajouté par erreur était énorme, vous remarquerez probablement que, même après l'avoir supprimé de l'index avec 'git reset', il semble toujours occuper de l'espace dans le répertoire .git.
Il n'y a pas de quoi s'inquiéter; le fichier est en effet toujours dans le référentiel, mais uniquement comme "objet libre". Il ne sera pas copié dans d'autres référentiels (via clone, push) et l'espace sera finalement récupéré - mais peut-être pas très bientôt. Si vous êtes anxieux, vous pouvez exécuter:
git gc --prune = maintenant
Mise à jour (ce qui suit est ma tentative de dissiper une certaine confusion qui peut découler des réponses les plus votées):
Alors, quelle est la véritable annulation de git add?
git reset HEAD ?
ou
git rm --cached ?
À proprement parler, et si je ne me trompe pas: aucune.
git add ne peut pas être annulé - en toute sécurité, en général.
Rappelons d'abord ce que fait réellement git add :
Si  n'a pas été suivi précédemment, git add l'ajoute àle cache, avec son contenu actuel.
Si  était déjà suivi, git add enregistre le contenu actuel (snapshot, version) dans le cache. Dans Git, cette action est toujours appelée add, (pas simplement le mettre à jour), car deux versions différentes (instantanés) d'un fichier sont considérées comme deux éléments différents: par conséquent, nous ajoutons effectivement un nouvel élément au cache, pour être finalement commis plus tard.
À la lumière de cela, la question est légèrement ambiguë:
J'ai ajouté des fichiers par erreur à l'aide de la commande ...
Le scénario de l'OP semble être le premier (fichier non suivi), nous voulons que "l'annulation" supprime le fichier (pas seulement le contenu actuel) des éléments suivis. Si tel est le cas, vous pouvez exécuter git rm --cached .
Et nous pourrions également exécuter git reset HEAD . C'est en général préférable, car cela fonctionne dans les deux scénarios: il effectue également l'annulation lorsque nous avons ajouté à tort une version d'un élément déjà suivi.
Mais il y a deux mises en garde.
Premièrement: il n'y a (comme indiqué dans la réponse) qu'un seul scénario dans lequel git reset HEAD ne fonctionne pas, mais git rm --cached le fait: un nouveau dépôt (pas de validation). Mais, vraiment, c'est un cas pratiquement hors de propos.
Deuxièmement: sachez que git reset HEAD ne peut pas récupérer par magie le contenu du fichier précédemment mis en cache, il le resynchronise simplement à partir de HEAD. Si notre git add mal orienté a écrasé une version précédente non validée, nous ne pouvons pas la récupérer. C'est pourquoi, à proprement parler, nous ne pouvons pas annuler [*].
Exemple:
$ git init
$ echo "version 1"> fichier.txt
$ git add file.txt # Premier ajout de file.txt
$ git commit -m 'premier commit'
$ echo "version 2"> fichier.txt
$ git add file.txt # Étape (ne pas valider) "version 2" de file.txt
$ git diff --fichier en cache.txt
-version 1
+ version 2
$ echo "version 3"> fichier.txt
$ git diff fichier.txt
-version 2
+ version 3
$ git add file.txt # Oups, nous ne voulions pas dire ça
$ git reset HEAD file.txt # Annuler?
$ git diff --cached file.txt # Pas de dif, bien sûr. étape == HEAD
$ git diff file.txt # Nous avons irrévocablement perdu la "version 2"
-version 1
+ version 3
Bien sûr, ce n'est pas très critique si nous suivons simplement le flux de travail paresseux habituel de faire 'git add' uniquement pour ajouter de nouveaux fichiers (cas 1), et nous mettons à jour de nouveaux contenus via la commande commit, git commit -a.
* (Edit: ce qui précède est pratiquement correct, mais il peut toujours y avoir des moyens légèrement hackers / alambiqués pour récupérer des changements qui ont été mis en scène, mais non validés puis écrasés - voir les commentaires de Johannes Matokic et iolsmit)
|
Annuler un fichier qui a déjà été ajouté est assez simple avec Git. Pour réinitialiser myfile.txt, qui ont déjà été ajoutés, utilisez:
git reset HEAD monfichier.txt
Explication:
Après avoir mis en scène des fichiers indésirables, pour annuler, vous pouvez effectuer une réinitialisation git. La tête est la tête de votre fichier dans le local et le dernier paramètre est le nom de votre fichier.
J'ai créé les étapes de l'image ci-dessous plus en détail pour vous, y compris toutes les étapes qui peuvent se produire dans ces cas:
|
git rm - en cache. -r
"annulera" tout ce que vous avez ajouté de votre répertoire actuel de manière récursive
|
Courir
git gui
et supprimez tous les fichiers manuellement ou en les sélectionnant tous et en cliquant sur le bouton Annuler l'étape de la validation.
|
La question n'est pas clairement posée. La raison en est que git add a deux significations:
en ajoutant un nouveau fichier dans la zone de préparation, puis annulez avec git rm --cached file.
ajouter un fichier modifié à la zone de préparation, puis annuler avec git reset HEAD file.
En cas de doute, utilisez
git réinitialise le fichier HEAD
Parce qu'il fait la chose attendue dans les deux cas.
Attention: si vous faites git rm --cached file sur un fichier qui a été modifié (un fichier qui existait auparavant dans le référentiel), alors le fichier sera supprimé sur git commit! Il existera toujours dans votre système de fichiers, mais si quelqu'un d'autre extrait votre validation, le fichier sera supprimé de son arbre de travail.
git status vous dira si le fichier était un nouveau fichier ou modifié:
Sur le maître de succursale
Modifications à valider:
(utilisez "git reset HEAD  ..." pour désinstaller)
nouveau fichier: my_new_file.txt
modifié: mon_fichier_modifié.txt
|
Git a des commandes pour chaque action imaginable, mais il a besoin de connaissances approfondies pour bien faire les choses et à cause de cela, il est au mieux contre-intuitif ...
Ce que vous avez fait avant:
Modification d'un fichier et utilisation de git add., Ou git add .
Ce que tu veux:
Supprimez le fichier de l'index, mais gardez-le versionné et laissé avec des modifications non validées dans la copie de travail:
git reset HEAD 
Réinitialisez le fichier au dernier état de HEAD, annulez les modifications et supprimez-les de l'index:
# Pensez à `svn revert ` IIRC.
git reset HEAD 
git checkout 
# Si vous avez un «» nommé comme «», utilisez:
git checkout - 
Ceci est nécessaire car git reset --hard HEAD ne fonctionnera pas avec des fichiers uniques.
Supprimez  de l'index et du contrôle de version, en conservant le fichier sans version avec les modifications de la copie de travail:
git rm -  en cache
Supprimez complètement  de la copie de travail et du contrôle de version:
git rm 
|
Si vous êtes sur votre commit initial et que vous ne pouvez pas utiliser gitréinitialisez, déclarez simplement «faillite de Git» et supprimez le dossier .git et recommencez
|
Comme pour beaucoup d'autres réponses, vous pouvez utiliser git reset
MAIS:
J'ai trouvé ce super petit article qui ajoute en fait la commande Git (enfin, un alias) pour git unadd: voir git unadd pour plus de détails ou ..
Simplement,
git config --global alias.unadd "reset HEAD"
Maintenant vous pouvez
git unadd foo.txt bar.txt
|
Utilisez git add -i pour supprimer les fichiers récemment ajoutés de votre prochain commit. Exemple:
Ajout du fichier que vous ne vouliez pas:
$ git add foo
$ git status
# Sur le maître de succursale
# Modifications à valider:
# (utilisez "git reset HEAD  ..." pour désinstaller)
#
# nouveau fichier: foo
#
# Fichiers non suivis:
# (utilisez "git add  ..." pour inclure ce qui sera validé)
# [...] #
Entrer dans l'ajout interactif pour annuler votre ajout (les commandes tapées ici sont "r" (revert), "1" (la première entrée de la liste s'affiche), 'return' pour abandonner le mode de retour, et "q" (quitter):
$ git add -i
chemin non mis en scène
1: + 1 / -0 rien foo
*** Commandes ***
1: [s] tatus 2: [u] pdate 3: [r] evert 4: [a] dd non suivi
5: [p] atch 6: [d] ssi 7: [q] uit 8: [h] elp
Et maintenant> r
chemin non mis en scène
1: + 1 / -0 rien [f] oo
Revenir >> 1
chemin non mis en scène
* 1: + 1 / -0 rien [f] oo
Revenir >>
note: foo n'est pas suivi maintenant.
retourné un chemin
*** Commandes ***
1: [s] état 2: [u] pdate 3: [r] evert 4: [a] jj non suivi
5: [p] atch 6: [d] ssi 7: [q] uit 8: [h] elp
Et maintenant> q
Au revoir.
$
C'est ça! Voici votre preuve, montrant que "foo" est de retour sur la liste non suivie:
$ git status
# Sur le maître de succursale
# Fichiers non suivis:
# (utilisez "git add  ..." pour inclure ce qui sera validé)
# [...]
# foo
rien d'ajouté à la validation mais des fichiers non suivis présents (utilisez "git add" pour suivre)
$
|
git remove ou git rm peuvent être utilisés pour cela, avec l'option --cached. Essayer:
git help rm
|
Voici un moyen d'éviter ce problème épineux lorsque vous démarrez un nouveau projet:
Créez le répertoire principal de votre nouveau projet.
Exécutez git init.
Créez maintenant un fichier .gitignore (même s'il est vide).
Validez votre fichier .gitignore.
Git rend très difficile la réinitialisation de git si vous n'avez pas de commits. Si vous créez un tout petit commit initial juste pour en avoir un, après cela, vous pouvez git add -A et git reset autant de fois que vous le souhaitez pour que tout soit bien.
Un autre avantage de cette méthode est que si vous rencontrez des problèmes de fin de ligne plus tard et que vous devez actualiser tous vos fichiers, c'est facile:
Découvrez ce commit initial. Cela supprimera tous vos fichiers.
Vérifiez à nouveau votre dernier commit. Cela récupérera de nouvelles copies de vos fichiers, en utilisant vos paramètres de fin de ligne actuels.
|
Peut-être que Git a évolué depuis que vous avez publié votre question.
$> git --version
git version 1.6.2.1
Maintenant, vous pouvez essayer:
git reset HEAD.
Cela devrait être ce que vous recherchez.
|
Notez que si vous ne spécifiez pas une révision, vous devez inclure un séparateur. Exemple de ma console:
git reset 
fatal: argument ambigu '': révision inconnue ou chemin non dans l'arborescence de travail.
Utilisez '-' pour séparer les chemins des révisions
git reset - 
Modifications non organisées après la réinitialisation:
M 
(Git version 1.7.5.4)
|
Pour supprimer de nouveaux fichiers de la zone de préparation (et uniquement en cas de nouveau fichier), comme suggéré ci-dessus:
git rm - FICHIER en cache
Utilisez rm --cached uniquement pour les nouveaux fichiers ajoutés accidentellement.
|
Pour réinitialiser chaque fichier dans un dossier particulier (et ses sous-dossiers), vous pouvez utiliser la commande suivante:
git reset *
|
Utilisez la commande * pour gérer plusieurs fichiers à la fois:
git reset HEAD * .prj
git reset HEAD * .bmp
git reset HEAD * gdb *
etc.
|
Tapez simplement git reset, il reviendra et c'est comme si vous n'aviez jamais tapé git add. depuis votre dernier commit. Assurez-vous que vous vous êtes déjà engagé.
|
Supposons que je crée un nouveau fichier, newFile.txt:
Supposons que j'ajoute le fichier accidentellement, git add newFile.txt:
Maintenant, je veux annuler cet ajout, avant de commettre, git reset newFile.txt:
|
Pour un fichier spécifique:
git reset mon_fichier.txt
git checkout mon_fichier.txt
Pour tous les fichiers ajoutés:
git reset.
git checkout.
Remarque: l'extraction modifie le code dans les fichiers et passe au dernier état mis à jour (validé). la réinitialisation ne change pas les codes; il réinitialise simplement l'en-tête.
|
Pour annuler git add, utilisez:
git réinitialise le nom du fichier
|
Cette commande supprimera vos modifications:
git reset HEAD filename.txt
Vous pouvez aussi utiliser
git add -p
pour ajouter des parties de fichiers.
|
Il existe également un mode interactif:
git add -i
Choisissez l'option 3 pour annuler l'ajout de fichiers. Dans mon cas, je souhaite souvent ajouter plus d'un fichier, et avec le mode interactif, vous pouvez utiliser des nombres comme celui-ci pour ajouter des fichiers. Cela prendra tout sauf 4: 1, 2, 3 et 5
Pour choisir une séquence, tapez simplement 1-5 pour prendre tout de 1 à 5.
Fichiers intermédiaires Git
|
git add myfile.txt # Cela ajoutera votre fichier dans la liste à valider
Tout le contraire de cette commande est,
git reset HEAD myfile.txt # Cela annulerail.
ainsi, vous serez dans l'état précédent. Spécifié sera à nouveau dans la liste non suivie (état précédent).
Il réinitialisera votre tête avec ce fichier spécifié. donc, si votre tête ne l'a pas, cela la réinitialisera simplement.
|
git reset filename.txt
Supprime un fichier nommé filename.txt de l'index actuel, la zone "sur le point d'être validée", sans rien changer d'autre.
|
git reset filename.txt
Supprime un fichier nommé filename.txt de l'index actuel, la zone "sur le point d'être validée", sans rien changer d'autre.
|
Dans Sourcetree, vous pouvez le faire facilement via l'interface graphique.
Vous pouvez vérifier quelle commande Sourcetree utilise pour désinstaller un fichier.
J'ai créé un nouveau fichier et l'ai ajouté à Git. Ensuite, je l'ai désinstallé à l'aide de l'interface graphique Sourcetree.
Voici le résultat:
Suppression des fichiers [08/12/15 10:43]
git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = sourcetree reset -q - chemin / vers / fichier / nom de fichier.java
Sourcetree utilise la réinitialisation pour désinstaller de nouveaux fichiers.
|
1
2
Prochain
Question très active. Gagnez 10 points de réputation pour répondre à cette question. L'exigence de réputation permet de protéger cette question contre les spams et les activités sans réponse.
Ce n'est pas la réponse que vous recherchez? Parcourez les autres questions marquées git version-control git-commit git-stage ou posez votre propre question.